﻿#include<iostream>

using namespace std;

//class A
//{
//
//};
//class B
//{
//protected:
//	A _a; 
//};
//int main()
//{
//	
//	return 0;
//}

//class Person
//{
//public:
//	virtual void print() { cout << "买票 - 全价" << endl; }
//};
//
//
//class Student : public Person
//{
//public:
//	virtual void print() { cout << "买票-打折" << endl; }
//};
////实现多态必须是指针或引用调用虚函数
//void fun(Person& x)
////void fun(Person* x)
//{
//	x.print();
//
//	//x->print();
//}
//
//
//int main()
//{
//	Student s1;
//	Person s2;
//	fun(s1);
//	fun(s2);
//
//	return 0;
//}


//class Person
//{
//public:
//	virtual void print() { cout << "Person"  << endl; }
//};
//class Student : public Person
//{
//public:
//	virtual void print() { cout << "Student" << endl; }
//};
//
//void fum(Person x)
//{
//	//x->print();
//}
//int main()
//{
//	Student sobj;
//	// 1.派⽣类对象可以赋值给基类的指针/引⽤ 
//	Person pp;
//	fum(sobj);
//	fum(pp);
//	return 0;
//}

//class Person
//{
//public:
//	virtual void print() { cout << "米米" << endl; }
//};
//
//class Student : public Person
//{
//public:
//	virtual void print() { cout << "姬霓太美" << endl; }
//};
//
//void fang(Person* x)
//{
//	x->print();
//}
//
//int main()
//{
//	Student jntm;
//	Person mimi;
//	fang(&jntm);
//	fang(&mimi);
//	fang(&mimi);
//	return 0;
//}
//class A {};
//class B : public A {};
//
//class Person
//{
//public:
//	virtual A* print()
//	{
//		cout << "1111" << endl;
//		return nullptr;
//	}
//};
//
//class Student : public Person
//{
//public:
//	 B* print()
//	{
//		cout << "姬霓太美" << endl;
//		return nullptr;
//	}
//};
//void fang(Person* x)
//{
//	x->print();
//}
//
//int main()
//{
//	Student s1;
//	Person s2;
//	fang(&s1);
//	fang(&s2);
//	return 0;
//}


//class A
//{
//public:
//	  virtual ~A()
//	{
//		cout << "~A()" << endl;
//	}
//};
//class B : public A {
//public:
//	 ~B()
//	{
//		cout << "~B()->delete:" << _p << endl;
//		delete _p;
//	}
//protected:
//	int* _p = new int[10];
//};
//// 只有派⽣类Student的析构函数重写了Person的析构函数，下⾯的delete对象调⽤析构函数，才能构成多态，才能保证p1和p2指向的对象正确的调⽤析构函数。
//int main()
//{
//	A* p1 = new A;
//	A* p2 = new B;
//	delete p1;
//	delete p2;
//	return 0;
//}
//


// Student的_num和Person的_num构成隐藏关系，可以看出这样代码虽然能跑，但是⾮常容易混淆 
//class Person
//{
//public:
//	void print()
//	{
//		cout << "您好" << endl;
//	}
//protected:
//	string _st = "李4"; // 姓名 
//	int _num = 99;      //年龄
//};
//
//class Student : public Person
//{
//public:
//	void print()
//	{
//		cout << "姓名:" << _st << endl;
//		cout << "年龄:" << Person::_num << endl;
//	}
//protected:
//	int _num = 10; //年龄
//};
//int main()
//{
//	Student s1;
//	s1.Person::print();
//
//	return 0;
//}

//class A
//{
//public:
//	void fun()
//	{
//		cout << "func()" << endl;
//	}
//};
//class B : public A
//{
//public:
//	void fun(int i)
//	{
//		cout << "func(int i)" << i << endl;
//	}
//};
//int main()
//{
//	B b;
//	b.fun(10);
//	b.A::fun();
//
//	return 0;
//};

//class Person
//{
//public:
//	Person(const char* name = "peter")
//		: _name(name)
//	{
//		cout << "Person()" << endl;
//	}
//	Person(const Person& p)
//		: _name(p._name)
//	{
//		cout << "Person(const Person& p)" << endl;
//	}
//	Person& operator=(const Person& p)
//	{
//		cout << "Person operator=(const Person& p)" << endl;
//		if (this != &p)
//			_name = p._name;
//		return *this;
//	}
//	~Person()
//	{
//		cout << "~Person()" << endl;
//	}
//protected:
//	string _name; // 姓名
//};
//class Student : public Person
//{
//public:
//	Student(const char* name, int num)
//		: Person(name)
//		, _num(num)
//	{
//		cout << "Student()" << endl;
//	}
//	Student(const Student& s)
//		: Person(s)
//		, _num(s._num)
//	{
//		cout << "Student(const Student& s)" << endl;
//	}
//	Student& operator = (const Student& s)
//	{
//		cout << "Student& operator= (const Student& s)" << endl;
//		if (this != &s)
//		{
//			// 构成隐藏，所以需要显⽰调⽤
//			Person::operator =(s);
//			_num = s._num;
//		}
//		return *this;
//	}
//	~Student()
//	{
//		cout << "~Student()" << endl;
//	}
//protected:
//	int _num; //学号
//};
//int main()
//{
//	Student s1("jack", 18);
//	Student s2(s1);
//	Student s3("rose", 17);
//	s1 = s3;
//	return 0;
//}
//


//// C++11的⽅法
//class Base final
//{
//public:
//	void func5() { cout << "Base::func5" << endl; }
//protected:
//	int a = 1;
//private:
//	// C++98的⽅法
//	/*Base()
//	{}*/
//};
//class Derive :public Base
//{
//	void func4() { cout << "Derive::func4" << endl; }
//protected:
//	int b = 2;
//};
//
//int main()
//{
//	Base b;
//	Derive d;
//	return 0;
//}
//


//class Student;
//
//class Person
//{
//public:
//	friend void Display(const Person& p, const Student& s);
//protected:
//	string _name; // 姓名
//};
//
//class Student : public Person
//{
//protected:
//	int _stuNum; // 学号
//};
//
//void Display(const Person& p, const Student& s)
//{
//	cout << p._name << endl;
//	cout << s._stuNum << endl;
//}
//
//int main()
//{
//	Person p;
//	Student s;
//	// 编译报错：error C2248: “Student::_stuNum”: ⽆法访问 protected 成员
//	// 解决⽅案：Display也变成Student 的友元即可
//	Display(p, s);
//	return 0;
//}

//class Person
//{
//public:
//	string _name;
//	static int _count;
//};
//int Person::_count = 0;
//class Student : public Person
//{
//protected:
//	int _stuNum;
//};
//int main()
//{
//	Person p;
//	Student s;
//	// 这⾥的运⾏结果可以看到⾮静态成员_name的地址是不⼀样的
//	// 说明派⽣类继承下来了，⽗派⽣类对象各有⼀份
//	cout << &p._name << endl;
//	cout << &s._name << endl;
//	// 这⾥的运⾏结果可以看到静态成员_count的地址是⼀样的
//	// 说明派⽣类和基类共⽤同⼀份静态成员
//	cout << &p._count << endl;
//	cout << &s._count << endl;
//	// 公有的情况下，⽗派⽣类指定类域都可以访问静态成员
//	cout << Person::_count << endl;
//	cout << Student::_count << endl;
//	return 0;
//}

class A
{
public:
	virtual ~A()
	{
		cout << "~A()" << endl;
	}
};
class B : public A {
public:
	~B()
	{
		cout << "~B()->delete:" << _p << endl;
		delete _p;
	}
protected:
	int* _p = new int[10];
};
// 只有派⽣类Student的析构函数重写了Person的析构函数，下⾯的delete对象调⽤析构函数，才能构成多态，才能保证p1和p2指向的对象正确的调⽤析构函数。
int main()
{
	A* p1 = new A;
	A* p2 = new B;
	delete p1;
	delete p2;
}